package com.example.algorithm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 定时系统算法设计题
 *
 * @author huahua
 * @DATE 2024/10/19
 **/
public class TimerSystem {

    public static void main(String[] args) {
        MyTimerSystem myTimerSystem = new MyTimerSystem();
        myTimerSystem.TimerSystem(new int[]{3, 5});
        System.out.println(myTimerSystem.timerStart(0));
        System.out.println(myTimerSystem.timerStart(1));
        System.out.println(Arrays.deepToString(myTimerSystem.runTimerSystem(17)));
        System.out.println(myTimerSystem.timerStop(1));
        System.out.println(Arrays.deepToString(myTimerSystem.runTimerSystem(20)));
        System.out.println(myTimerSystem.timerStop(1));
        System.out.println(myTimerSystem.timerStop(2));
    }

    static class MyTimerSystem {

        // 定义一个定时器结构体，存储间隔周期、开始时间和启动状态
        static class Timer {
            // 间隔周期
            int period;
            // 开始时间
            int startTime;
            // 启动状态
            boolean isStart;

            Timer(int period, int startTime, boolean isStart) {
                this.period = period;
                this.startTime = startTime;
                this.isStart = isStart;
            }
        }

        // 定义一个Map存储定时器编号和定时器结构体对应关系
        Map<Integer, Timer> map = new HashMap<>();

        // 定义当前时间
        int curTime = 0;

        // 初始化定时系统，下标i为定时器编号，值为周期。初始为0，默认不启动
        void TimerSystem(int[] times) {
            for (int i = 0; i < times.length; i++) {
                map.put(i, new Timer(times[i], curTime, false));
            }
        }

        // 启动定时器，参数timerId为定时器编号
        boolean timerStart(int timerId) {
            if (map.containsKey(timerId)) {
                map.get(timerId).startTime = curTime;
                map.get(timerId).isStart = true;
                return true;
            }
            return false;
        }

        // 停止定时器，参数timerId为定时器编号
        boolean timerStop(int timerId) {
            if (map.containsKey(timerId)) {
                map.get(timerId).isStart = false;
                return true;
            }
            return false;
        }

        /**
         * 设置当前系统时间为nowTime，对所有定时器进行超时处理。
         * 从上次调用时刻到nowtime，按照格式为[time,timeId]输出每个定时器的超时信息。
         * 超时信息先按照time升序，如果time相同再按照timeId升序。
         */
        int[][] runTimerSystem(int nowTime) {
            if (map == null || curTime > nowTime) {
                return null;
            }

            List<int[]> list = new ArrayList<>();
            for (Integer timeId : map.keySet()) {
                Timer timer = map.get(timeId);
                if (timer != null && timer.isStart) {
                    for (int i = curTime - timer.startTime; i <= nowTime - timer.startTime; i++) {
                        if (i % timer.period == 0 && i >= timer.period) {
                            list.add(new int[]{i + timer.startTime, timeId});
                        }
                    }
                }
            }

            // 先按照time升序，如果time相同再按照timeId升序
            list.sort((o1, o2) -> {
                if (o1[0] != o2[0]) {
                    return Integer.compare(o1[0], o2[0]);
                } else {
                    return Integer.compare(o1[1], o2[1]);
                }
            });

            // 创建二维数组，存储结果
            int[][] result = new int[list.size()][];
            for (int i = 0; i < list.size(); i++) {
                result[i] = list.get(i);
            }
            curTime = nowTime;
            return result;
        }
    }
}
